﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using ITProject.Domain;
using ITProject.Domain.Entities;
using ITProject.Repository.Abstract;
using System.Data.Entity.Infrastructure;
using System.Data;

namespace ITProject.Repository.Concrete
{
    /// <summary>
    /// Repozytorium projektów z bazy danych ITProject.
    /// Autor: Jakub Szatkowski
    /// </summary>
    public class ProjectRepository : IProjectRepository
    {
        private EFDataContext _dataContext = new EFDataContext();

        /// <summary>
        /// Metoda, która dodaje nowy projekt do bazy danych.
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <param name="project">Projekt do dodania</param>
        /// <param name="project">Login użytkownika zakładającego projekt</param>
        public void Add(Project project,string userName)
        {
            User user = _dataContext.Users.Where(x => x.Login == userName).FirstOrDefault();
            // zapisanie właściciela projektu
            project.IdOwner = user.Id;
            _dataContext.Project.Add(project);
            _dataContext.SaveChanges();
            // zapisujemy relacje między projektem a założycielem
            ProjectUser projectUserRelationship = new ProjectUser();
            projectUserRelationship.ProjectId = project.Id;
            projectUserRelationship.UserId = user.Id;
            projectUserRelationship.RoleId = (byte)UserRole.Supervisor;
            _dataContext.ProjectUser.Add(projectUserRelationship);
            _dataContext.SaveChanges();
        }

        /// <summary>
        /// Metoda pozwalająca edytować opisy i logo projektu.
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <param name="editedProject">Wyedytowany projekt.</param>
        public void EditProject(Project editedProject)
        {
            Project projectInDatabase = _dataContext.Project.Where(x => x.Id == editedProject.Id).FirstOrDefault();
            projectInDatabase.LogoPath = editedProject.LogoPath;
            projectInDatabase.ShortDescription = editedProject.ShortDescription;
            projectInDatabase.Description = editedProject.Description;
            DbEntityEntry entry = _dataContext.Entry(projectInDatabase);
            entry.State = EntityState.Modified;
            _dataContext.SaveChanges();
        }

        /// <summary>
        /// Funkcja zapisuje zmiane roli uzytkownika
        /// </summary>
        /// <param name="idUser">id uzytkownika</param>
        /// <param name="newRole">nowa rola</param>
        public void EditRole(int idUser, int newRole, int idProject)
        {
            ProjectUser pu = _dataContext.ProjectUser.Where(x => (x.UserId == idUser && x.ProjectId == idProject)).First();
            if (pu.RoleId == newRole)
                return;
            pu.RoleId = (byte)newRole;
            DbEntityEntry entry = _dataContext.Entry(pu);
            entry.State = EntityState.Modified;
            _dataContext.SaveChanges();
        }

        /// <summary>
        /// Metoda zwracająca listę wszystkich projektów w serwisie ITProject.
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <returns>Kolekcja projektów.</returns>
        public IEnumerable<Project> GetProjects()
        {
            return _dataContext.Project;
        }

        /// <summary>
        /// Metoda pobieracjąca encję projektu na podstawie jego nazwy.
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <param name="name">Nazwa projektu.</param>
        /// <returns>Obiekt encji projektu.</returns>
        public Project GetProjectByName(string name)
        {
            return _dataContext.Project.Where(x => (x.Name == name)).FirstOrDefault();
        }

        public bool IsUserInProject(int idp, int idu)
        {
            
            if (_dataContext.ProjectUser.Where(x => x.ProjectId == idp && x.UserId == idu).Count() > 0)
                return true;
            return false;

        }

        /// <summary>
        /// Metoda pozwalająca pobrać użytkowników projektu wraz z rolami.
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <param name="users">Użytkownicy projektu</param>
        /// <param name="roles">Role użytkowników projektu.</param>
        /// <param name="projectName">Nazwa projektu</param>
        public void GetProjectUsers(out User[] users, out UserRole[] roles, string projectName)
        {
            Project p=GetProjectByName(projectName);
            var projectUsers = _dataContext.ProjectUser.Where(x => (x.ProjectId == p.Id));
            users=new User[projectUsers.Count()];
            roles=new UserRole[projectUsers.Count()];
            int i=0;
            foreach (ProjectUser pu in projectUsers)
            {
                users[i] = _dataContext.Users.Where(x => x.Id == pu.UserId).FirstOrDefault();
                roles[i] = (UserRole)pu.RoleId;
                i++;
            }
        }

        /// <summary>
        /// Metoda pozwalająca na pobranie roli użytkownika w danym projekcie.
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <param name="projectName">Nazwa projektu</param>
        /// <param name="userName">Login użytkownika</param>
        /// <returns>Rola użytkownika w projekcie</returns>
        public UserRole GetProjectUserRole(string projectName, string userName)
        {
            User user = _dataContext.Users.Where(x => (x.Login == userName)).FirstOrDefault();
            Project project = GetProjectByName(projectName);
            ProjectUser projectUser = _dataContext.ProjectUser.Where(x => (x.UserId == user.Id && x.ProjectId == project.Id)).FirstOrDefault();
            if (projectUser == null)
                return UserRole.NoRole;
            return (UserRole)projectUser.RoleId;
        }

        /// <summary>
        /// Metoda pozwala pobrać identyfikatory zaproszonych do projektu użytkowników.
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <param name="projectName">Nazwa projektu</param>
        /// <returns>Identyfikatory zaproszonych do tego projektu użytkowników.</returns>
        public int[] GetIdInvitedUsers(string projectName)
        {
            Project project = GetProjectByName(projectName);
            var invitedUsers=_dataContext.Invitation.Where(x=>(x.ProjectId==project.Id)).Select(x=>x.UserId);
            int[] invitedUsersId = invitedUsers.ToArray();
            return invitedUsersId;
        }

        /// <summary>
        /// Metoda pozwalająca zaprosić użytkownika do projektu.
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <param name="projectName">Nazwa projektu</param>
        /// <param name="userId">Id zapraszanego użytkownika</param>
        public void Invite(string projectName, int userId)
        {
            Project project = GetProjectByName(projectName);
            Invite(project.Id, userId);
        }

        /// <summary>
        /// Metoda pozwalająca zaprosić użytkownika do projektu.
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <param name="projectName">Identyfikator projektu.</param>
        /// <param name="userId">Id zapraszanego użytkownika.</param>
        public void Invite(int projectId, int userId)
        {
            Invitation invitation = new Invitation
            {
                ProjectId = projectId,
                UserId = userId,
                DateOfInvitation = DateTime.Now
            };
            _dataContext.Invitation.Add(invitation);
            _dataContext.SaveChanges();
        }

        /// <summary>
        /// Metoda pozwala na usunięcie użytkownika projektu.
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <param name="projectId">Identyfikator projektu.</param>
        /// <param name="userId">Identyfikator użytkownika.</param>
        /// <returns>Prawda jeśli użytkownika został usunięty z projektu, fałsz jeśli nie ma użytkownika w projekcie.</returns>
        public bool DeleteUserFromProject(int projectId, int userId)
        {
            ProjectUser pu=_dataContext.ProjectUser.Where(x=>(x.ProjectId==projectId && x.UserId==userId)).FirstOrDefault();
            if (pu == null)
                return false;
            _dataContext.ProjectUser.Remove(pu);
            _dataContext.SaveChanges();
            return true;
        }

        /// <summary>
        /// Metoda pozwala pobrać identyfikator projektu.
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <param name="projectName">Nazwa projektu.</param>
        /// <returns>Identyfikator projektu.</returns>
        public int GetProjectId(string projectName)
        {
            return _dataContext.Project.Where(x => (x.Name == projectName)).FirstOrDefault().Id;
        }

        /// <summary>
        /// Metoda pozwala pobrać encję projektu.
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <param name="projectName">Identyfikator projektu.</param>
        /// <returns>Obiekt projektu.</returns>
        public Project GetProjectById(int projectId)
        {
            return _dataContext.Project.Where(x => (x.Id == projectId)).FirstOrDefault();
        }

        /// <summary>
        /// Akceptacja zaproszenia uczestnictwa w projekcie.
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <param name="projectId">Identyfikator projektu.</param>
        /// <param name="userId">Identyfikator użytkownika.</param>
        /// <returns>Prawda jeśli zaproszenie istnieje.</returns>
        public bool AcceptInvitation(int projectId, int userId)
        {
            Invitation inv = _dataContext.Invitation.Where(x => (x.ProjectId == projectId && x.UserId == userId)).First();
            if (inv == null)
                return false;
            _dataContext.Invitation.Remove(inv);
            _dataContext.SaveChanges();
            User user = _dataContext.Users.Where(x => x.Id == userId).FirstOrDefault();
            Project project = _dataContext.Project.Where(p => p.Id == projectId).FirstOrDefault();
            AddUserToProject(projectId,userId);
            return true;
        }

        /// <summary>
        /// Metoda dodaje użytkownika do projektu.
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <param name="projectId">Identyfikator projektu.</param>
        /// <param name="userId">Identyfikator użytkownika.</param>
        public void AddUserToProject(int projectId, int userId)
        {
            ProjectUser projectUserRelationship = new ProjectUser();
            projectUserRelationship.ProjectId = projectId;
            projectUserRelationship.UserId = userId;
            projectUserRelationship.RoleId = (byte)UserRole.User;
            _dataContext.ProjectUser.Add(projectUserRelationship);
            _dataContext.SaveChanges();
        }

        /// <summary>
        /// Odrzucenie zaproszenia uczestnictwa w projekcie.
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <param name="projectId">Identyfikator projektu.</param>
        /// <param name="userId">Identyfikator użytkownika.</param>
        /// <returns>Prawda jeśli zaproszenie istnieje.</returns>
        public bool RejectInvitation(int projectId, int userId)
        {
            Invitation inv = _dataContext.Invitation.Where(x => (x.ProjectId == projectId && x.UserId == userId)).First();
            if (inv == null)
                return false;
            _dataContext.Invitation.Remove(inv);
            _dataContext.SaveChanges();
            return true;
        }

        public void GetUserProject(int idUser,out List<string> uproject,out List<string> sproject)
        {
            IQueryable<ProjectUser> list = _dataContext.ProjectUser.Where(x => (x.UserId == idUser));
            uproject=_dataContext.Project.Join(list, Project => Project.Id, ProjectUser => ProjectUser.ProjectId, (Project, ProjectUser) => new { projectName=Project.Name, idRole=ProjectUser.RoleId }).Where(x=>x.idRole==1).Select(x=>x.projectName).ToList();
            sproject = _dataContext.Project.Join(list, Project => Project.Id, ProjectUser => ProjectUser.ProjectId, (Project, ProjectUser) => new { projectName = Project.Name, idRole = ProjectUser.RoleId }).Where(x => x.idRole == 2).Select(x => x.projectName).ToList();
        }

        /// <summary>
        /// Metoda pozwala na pobranie obiektu encji właściciela projektu.
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <param name="projectName">Nazwa projektu</param>
        /// <returns>Właściciel projektu</returns>
        public User GetProjectOwner(string projectName)
        {
            Project project = GetProjectByName(projectName);
            User user = _dataContext.Users.Where(x => x.Id == project.IdOwner).FirstOrDefault();
            return user;
        }

        /// <summary>
        /// Metoda pozwalająca pobrać wszystkie zespoły w danym projekcie.
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <param name="projectName">Nazwa projektu.</param>
        /// <returns>Kolekacja zespołów projektu.</returns>
        public IEnumerable<Team> GetProjectTeams(string projectName)
        {
            Project project = GetProjectByName(projectName);
            return _dataContext.Team.Where(x => x.ProjectId == project.Id).AsEnumerable();
        }

        /// <summary>
        /// Metoda pozwalająca na dodanie nowego zespołu.
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <param name="team">Obiekt zespołu.</param>
        public void AddNewTeam(Team team)
        {
            _dataContext.Team.Add(team);
            // jesli lider nie jest supervisorem to dajemy mu status managera (lidera zespolu)
            ProjectUser projectUser=_dataContext.ProjectUser.Where(x => x.ProjectId == team.ProjectId && x.UserId==team.LeaderId).FirstOrDefault();
            if (projectUser.RoleId != (byte)UserRole.Supervisor)
                projectUser.RoleId = (byte)UserRole.Manager;
            DbEntityEntry entry = _dataContext.Entry(projectUser);
            entry.State = EntityState.Modified;
            _dataContext.SaveChanges();
        }
        /// <summary>
        /// Metoda zwraca id zespolu
        /// Natalia Wyczislok
        /// </summary>
        /// <param name="treamName"></param>
        /// <returns></returns>
        public int GetTeamId(string teamName,int idproject)
        {
            return _dataContext.Team.Where(x => (x.Name == teamName && x.ProjectId==idproject)).First().Id;
        }

        /// <summary>
        /// Zwraca loginy uzytkownikow w projekcie
        /// Natalia Wyczislok
        /// </summary>
        /// <param name="idteam"></param>
        /// <returns></returns>
        public List<String> GetTeamUsers(int idteam)
        {
            IEnumerable<TeamUser> tusers= _dataContext.TeamUser.Where(x => x.TeamId==idteam);
            return _dataContext.Users.Join(tusers, users => users.Id, teamu => teamu.UserId, (users, teamu) => new { name = users.Login }).Select(x=>x.name).ToList();
        }

        /// <summary>
        /// Metoda zwraca loginy uzytkownikow projektu
        /// Natalia Wyczislok
        /// </summary>
        /// <param name="idproject"></param>
        /// <returns></returns>
        public List<String> GetProjectUsersLogin(int idproject)
        {
            IEnumerable<ProjectUser> ppusers = _dataContext.ProjectUser.Where(x => x.ProjectId == idproject);
            return _dataContext.Users.Join(ppusers, users => users.Id, pusers => pusers.UserId, (users, pusers) => new { Name = users.Login }).Select(x=>x.Name).ToList();
        }

        /// <summary>
        /// Metoda dodaje uczestnika do zespołu.
        /// Natalia Wyczislok
        /// </summary>
        /// <param name="idteamu"></param>
        /// <param name="iduser"></param>
        public void AddUserToTeam(int idteamu, int iduser)
        {
            TeamUser tm = new TeamUser();
            tm.TeamId = idteamu;
            tm.UserId = iduser;
            _dataContext.TeamUser.Add(tm);
            _dataContext.SaveChanges();
        }

        /// <summary>
        /// Metoda usuwa uczestnika z zespołu.
        /// Natalia Wyczislok
        /// </summary>
        /// <param name="idteamu"></param>
        /// <param name="iduser"></param>
        /// <returns></returns>
        public bool RemoveUserFromTeam(int idteamu, int iduser)
        {
            TeamUser pu = _dataContext.TeamUser.Where(x => (x.TeamId == idteamu && x.UserId == iduser)).First();
            if (pu == null)
                return false;
            _dataContext.TeamUser.Remove(pu);
            _dataContext.SaveChanges();
            return true;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="projectName"></param>
        /// <param name="tems"></param>
        /// <param name="leaders"></param>
        /// <param name="users"></param>
        public void GetProjectTeams(string projectName, out Team[] teams, out string[] leaders, out User[][] users)
        {
            Project project = GetProjectByName(projectName);
            teams = _dataContext.Team.Where(x => x.ProjectId == project.Id).ToArray();
            leaders = new string[teams.Length];
            users = new User[teams.Length][];
            for (int i = 0; i < leaders.Length; i++)
            {
                Team team = teams[i];
                leaders[i] = _dataContext.Users.Where(x => x.Id == team.LeaderId).FirstOrDefault().Login;
                TeamUser[] teamUsers = _dataContext.TeamUser.Where(x => x.TeamId == team.Id).ToArray();
                users[i] = new User[teamUsers.Length];
                for (int j = 0; j < teamUsers.Length; j++)
                {
                    TeamUser teamUser = teamUsers[j];
                    users[i][j] = _dataContext.Users.Where(x => x.Id == teamUser.UserId).FirstOrDefault();
                }
            }
        }

        /// <summary>
        /// Metoda zwraca nazwe lidera grupy
        /// Natalia Wyczislok
        /// </summary>
        /// <param name="idTeam"></param>
        /// <returns></returns>
        public string GetTeamLeader(int idTeam)
        {
            int lid=_dataContext.Team.Where(x => x.Id == idTeam).Select(x => x.LeaderId).First();
            return _dataContext.Users.Where(x => x.Id == lid).Select(x => x.Login).First();
        }

        /// <summary>
        /// Metoda pozwala pobrać obiekt encji zespołu poprzez podanie jego identyfikatora.
        /// </summary>
        /// <param name="idTeam">Identyfikator zespołu.</param>
        /// <returns>Zespół.</returns>
        public Team GetTeamById(int idTeam)
        {
            return _dataContext.Team.Where(x => x.Id == idTeam).FirstOrDefault();
        }

        /// <summary>
        /// Metoda pozwalająca na edycję zespołu.
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <param name="team">Zespół do edycji z nowymi danymi.</param>
        public void EditTeam(Team team)
        {
            Team teamToEdit = _dataContext.Team.Where(x => x.Id == team.Id).FirstOrDefault();
            teamToEdit.Name = team.Name;
            teamToEdit.Description = team.Description;
            if (teamToEdit.LeaderId != team.LeaderId)
            {
                // jesli zmieniamy lidera to trzeba dopisac tego lidera uczestnika zespołu
                // a nowego lidera usunąć z uczestników zespołu
                int oldLeaderId=teamToEdit.LeaderId;
                TeamUser newTu = new TeamUser { TeamId = teamToEdit.Id, UserId = teamToEdit.LeaderId };
                _dataContext.TeamUser.Add(newTu);
                TeamUser oldTu = _dataContext.TeamUser.Where(x => x.TeamId == teamToEdit.Id && x.UserId == team.LeaderId).FirstOrDefault();
                if (oldTu != null)
                    _dataContext.TeamUser.Remove(oldTu);
                teamToEdit.LeaderId = team.LeaderId;

                 DbEntityEntry entry = _dataContext.Entry(teamToEdit);
                entry.State = EntityState.Modified;
                _dataContext.SaveChanges();

                // nowy lider bedzie mial status managera w teamie
                ProjectUser puNewLeader = _dataContext.ProjectUser.Where(x => x.ProjectId == team.ProjectId && x.UserId == team.LeaderId).FirstOrDefault();
                if (puNewLeader.RoleId != (byte)UserRole.Supervisor)
                {
                    puNewLeader.RoleId = (byte)UserRole.Manager;
                    DbEntityEntry entry2 = _dataContext.Entry(puNewLeader);
                    entry2.State = EntityState.Modified;
                }

                // stary lider mozebyc tylko uzytkownikiem
                ProjectUser puOldLeader = _dataContext.ProjectUser.Where(x => x.ProjectId == team.ProjectId && x.UserId == oldLeaderId).FirstOrDefault();
                if (puOldLeader.RoleId != (byte)UserRole.Supervisor)
                {
                    // sprawdzamy czy ma jeszcze jakis team
                    Team tmpTeam = _dataContext.Team.Where(x => x.ProjectId == team.ProjectId && x.LeaderId == oldLeaderId).FirstOrDefault();
                    if (tmpTeam == null)
                    {
                        puOldLeader.RoleId = (byte)UserRole.User;
                        DbEntityEntry entry2 = _dataContext.Entry(puNewLeader);
                        entry2.State = EntityState.Modified;
                    }
                }

                _dataContext.SaveChanges();
            }
            else
            {
                DbEntityEntry entry = _dataContext.Entry(teamToEdit);
                entry.State = EntityState.Modified;
                _dataContext.SaveChanges();
            }
        }

        public List<Project> GetProjectByOwnerLogin(string login)
        {
            User user = _dataContext.Users.Where(x => x.Login == login).FirstOrDefault();
            return _dataContext.Project.Where(x => x.IdOwner == user.Id).ToList();
        }

        public List<ForumTopic> GetProjectForumTopics(int projectId)
        {
            return _dataContext.ForumTopic.Where(x => x.ProjectId == projectId).ToList();
        }

        public ForumTopic AddForumTopic(string topic, int autorId, int projectId)
        {
            ForumTopic top = new ForumTopic();
            top.AddDate = DateTime.Now;
            top.Topic = topic;
            top.AutorId = autorId;
            top.ProjectId = projectId;

            ForumTopic test = _dataContext.ForumTopic.Add(top);
            _dataContext.SaveChanges();
            return test;
        }

        public void AddPost(string content, int autorId, int TopicId)
        {
            Post post = new Post();
            post.AddDate = DateTime.Now;
            post.AutorId = autorId;
            post.Content = content;
            post.TopicId = TopicId;

            _dataContext.Post.Add(post);
            _dataContext.SaveChanges();
        }

        public string GetTopicName(int topicID)
        {
            return _dataContext.ForumTopic.Where(x => x.Id == topicID).FirstOrDefault().Topic;
        }

        #region Funckjonalności związane z Releasami

        /// <summary>
        /// Metoda pozwala dodać nową werję do projektu. Dodaje ona również zapis zmian historii statusu tego releasu
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <param name="release">Wersja.</param>
        /// <param name="userId">Identyfikator użytkownika dodającego wersję.</param>
        public void AddNewRelease(Release release, int userId)
        {
            _dataContext.Release.Add(release);
            StatusChange sc = new StatusChange { Comment = "Dodanie nowej wersji", NewStatus = release.Status, DateOfChange = DateTime.Now, OldStatus=null, UserId=userId };
            _dataContext.StatusChange.Add(sc);
            _dataContext.SaveChanges();
            // mam id status change i releasa musze teraz to polaczyc
            ReleaseStatusChange rsc = new ReleaseStatusChange { ReleaseId = release.Id, StatusChangeId = sc.Id };
            _dataContext.ReleaseStatusChange.Add(rsc);
            _dataContext.SaveChanges();
        }

        /// <summary>
        /// Metoda pozwalająca pobrać wszystkie wersje stworzone w danym projekcie.
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <param name="projectId">Identyfikator projektu.</param>
        /// <returns>Tablica z wersjami</returns>
        public Release[] GetProjectReleases(int projectId)
        {
           return _dataContext.Release.Where(x => x.ProjectId == projectId).ToArray();
        }

        /// <summary>
        /// Metoda pozwala pobrać dane o wybranej wersji konkretnego projektu.
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <param name="releaseName">Nazwa wersji.</param>
        /// <param name="projectId">Identyfikator projektu.</param>
        /// <returns>Obiekt wersji.</returns>
        public Release GetReleaseByName(string releaseName, int projectId)
        {
            return _dataContext.Release.Where(x => x.ProjectId == projectId && x.Name == releaseName).FirstOrDefault();
        }

        /// <summary>
        /// Metoda pozwala pobrać dane o wybranej wersji.
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <param name="releaseId">Identyfikator wersji.</param>
        /// <returns>Obiekt wersji.</returns>
        public Release GetReleaseById(int releaseId)
        {
            return _dataContext.Release.Where(x => x.Id == releaseId).FirstOrDefault();
        }

        /// <summary>
        /// Metoda pozwala zmienić status wybranej wersji.
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <param name="release">Dane o wersji.</param>
        /// <param name="newStatus">Nowy status.</param>
        /// <param name="comment">Komentarz zmiany statusu.</param>
        /// <param name="userId">Identyfikator użytkownika zmieniającego status.</param>
        public void ChangeReleaseStatus(Release release, Status newStatus, string comment, int userId)
        {
            StatusChange sc = new StatusChange { Comment = comment, OldStatus = release.Status, NewStatus = (byte)newStatus, DateOfChange = DateTime.Now, UserId=userId };
            _dataContext.StatusChange.Add(sc);
            release.Status = (byte)newStatus;
            DbEntityEntry entry = _dataContext.Entry(release);
            entry.State = EntityState.Modified;
            _dataContext.SaveChanges();
            _dataContext.ReleaseStatusChange.Add(new ReleaseStatusChange { ReleaseId=release.Id, StatusChangeId=sc.Id });
            _dataContext.SaveChanges();
        }

        /// <summary>
        /// Metoda pozwalająca wyedytować dane o wersji.
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <param name="release">Nowe dane o wersji.</param>
        public void EditRelease(Release release)
        {
            Release releaseInDataBase = _dataContext.Release.Where(x => x.Id == release.Id).FirstOrDefault();
            releaseInDataBase.Name = release.Name;
            releaseInDataBase.Description = release.Description;
            releaseInDataBase.PlannedEndDate = release.PlannedEndDate;
            DbEntityEntry entry = _dataContext.Entry(releaseInDataBase);
            entry.State = EntityState.Modified;
            _dataContext.SaveChanges();
        }

        /// <summary>
        /// Metoda pozwala pobrać wszystkei zmiany statusu danej wersji.
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <param name="release">Obiekt wersji.</param>
        /// <param name="statusChanges">Tablica zmian statusów wersji.</param>
        /// <param name="users">Tablica użytkowników zmieniających status.</param>
        public void GetReleaseStatusChanges(Release release, out StatusChange[] statusChanges, out string[] users)
        {
            int[] releaseStatusChangesId = _dataContext.ReleaseStatusChange.Where(x => x.ReleaseId == release.Id)
                .Select(x => x.StatusChangeId).ToArray();
            statusChanges = _dataContext.StatusChange
                .Where(x => releaseStatusChangesId.Contains(x.Id)).ToArray();
            users = new string[statusChanges.Length];
            for (int i=0; i<users.Length; i++)
            {
                StatusChange statusChange=statusChanges[i];
                users[i] = _dataContext.Users.Where(x => x.Id == statusChange.UserId).Select(x => x.Login).FirstOrDefault();
            }
        }

        #endregion

        #region Wymagania funkcjonalne

        /// <summary>
        /// Metoda pozwalająca pobrać kolekcję wymagań funkcjonalnych danego projektu.
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <param name="projectId">Identyfikator projektu.</param>
        /// <returns>Tablica wymagań funkcjonalnych projektu.</returns>
        public FunctionalRequirement[] GetProjectFunctionalRequirements(int projectId)
        {
            return _dataContext.FunctionalRequirement.Where(x => x.ProjectId == projectId).ToArray();
        }

        /// <summary>
        /// Metoda pozwalająca na dodanie do bazy nowego wymagania funkcjonalnego.
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <param name="fc">Obiekt klasy encji wymagania funkcjonalnego.</param>
        /// <returns>Automatycznie wygenerowany przez baze indetyfikator nowego wymagania w bazie.</returns>
        public int AddFunctionalRequirement(FunctionalRequirement fc)
        {
            _dataContext.FunctionalRequirement.Add(fc);
            _dataContext.SaveChanges();
            return fc.Id;
        }

        /// <summary>
        /// Metoda pozwala pobrać największe identyfikator istniejący w tabeli scenariuszy.
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <returns>Identyfikator scenariusza.</returns>
        public int? GetMaxScenarioId()
        {
            if (_dataContext.Scenario.Count() == 0)
                return null;
            return _dataContext.Scenario.Max(x => x.Id);
        }

        /// <summary>
        /// Metoda zapisuje do bazy scenariusze wymagania funkcjonalnego.
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <param name="scenarios">Lista scenariuszy do zapisania.</param>
        public void AddScenarios(List<Scenario> scenarios)
        {
            for (int i = 0; i < scenarios.Count; i++)
                _dataContext.Scenario.Add(scenarios[i]);
            _dataContext.SaveChanges();
        }

        /// <summary>
        /// Metoda pobierające wszystkie scenariusze danego wymagania funkcjonalnego.
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <param name="requirementId">Identyfikator wymagania.</param>
        /// <returns>Tablica scenariuszy wymagania.</returns>
        public Scenario[] GetRequirementScenarios(int requirementId)
        {
            return _dataContext.Scenario.Where(x => x.FunctionalRequirementId == requirementId).ToArray();
        }

        /// <summary>
        /// Metoda pozwalająca na usuwanie wybranego wymagania funkcjonalnego.
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <param name="requirementId">Identyfikator wymagania.</param>
        public void DeleteFunctionalRequirement(int requirementId)
        {
            FunctionalRequirement fr = _dataContext.FunctionalRequirement.Where(x => x.Id == requirementId).FirstOrDefault();
            if (fr == null)
                return;
            Scenario[] scenarios = _dataContext.Scenario.Where(x => x.FunctionalRequirementId == fr.Id).ToArray();
            for (int i = 0; i < scenarios.Length; i++)
                _dataContext.Scenario.Remove(scenarios[i]);
            FeatureFunctionalRequirement[] ffr=_dataContext.FeatureFunctionalRequirement.Where(x=>x.RequirementId==fr.Id).ToArray();
            for (int i = 0; i < ffr.Length; i++)
                _dataContext.FeatureFunctionalRequirement.Remove(ffr[i]);
            _dataContext.FunctionalRequirement.Remove(fr);
        }

        /// <summary>
        /// Metoda zwracająca wymaganie funckjonalne o odpowiednim identyfikatorze.
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <param name="requirementId">Identyfikator wymagania.</param>
        /// <returns>Obiekt wymagania funkcjonalnego.</returns>
        public FunctionalRequirement GetFunctionalRequirementById(int requirementId)
        {
            return _dataContext.FunctionalRequirement.Where(x => x.Id == requirementId).FirstOrDefault();   
        }

        #endregion

        #region Funkjonalności

        /// <summary>
        /// Metoda zwracająca wszystkie funkcjonalności w projekcie.
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <param name="projectId"></param>
        /// <returns>Tablica funkcjonalności.</returns>
        public Feature[] GetProjectFeatures(int projectId)
        {
            return _dataContext.Feature.Where(x => x.ProjectId == projectId).ToArray();
        }

        /// <summary>
        /// Metoda pozwala pobrać zespół do którego przypisana jest dana funkcjonalność.
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <param name="featureId">Identyfikator funkcjonalności.</param>
        /// <returns>Zespoł.</returns>
        public Team GetFeatureTeamByFeatureId(int featureId)
        {
            FeatureTeam ft = _dataContext.FeatureTeam.Where(x => x.FeatureId == featureId).FirstOrDefault();
            if (ft == null)
                return null;
            Team team = _dataContext.Team.Where(x => x.Id == ft.TeamId).FirstOrDefault();
            return team;
        }

        /// <summary>
        /// Metoda pozwala pobrać użytkownika do którego przypisana jest dana funkcjonalność.
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <param name="featureId">Identyfikator funkcjonalności.</param>
        /// <returns>Użytkownik.</returns>
        public User GetFeatureUserByFeatureId(int featureId)
        {
            FeatureUser fu = _dataContext.FeatureUser.Where(x => x.FeatureId == featureId).FirstOrDefault();
            if (fu == null)
                return null;
            User user = _dataContext.Users.Where(x => x.Id == fu.UserId).FirstOrDefault();
            return user;
        }

        /// <summary>
        /// Metoda pozwala dodać nową funkcjonalność do projektu.
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <param name="feature">Obiekt funkcjonalności.</param>
        /// <param name="receiver">Odbiorca funkcjonalności, czyli ktoś kto ma w projekcie tę funkcjonalność wykonać (uczestnik lub zespół).</param>
        /// <param name="creator">Identyfikator użytkownika, który dodał funkcjonalność.</param>
        public void AddNewFeature(Feature feature, string receiver,int creator)
        {
            _dataContext.Feature.Add(feature);
            // dodanie zmiany statusu funkcjonalności
            StatusChange sc = new StatusChange
            {
                Comment = "Dodanie nowej funkcjonalności",
                DateOfChange = DateTime.Now,
                NewStatus = feature.Status,
                OldStatus = null,
                UserId = creator
            };
            _dataContext.StatusChange.Add(sc);
            // pierwszy zapis
            _dataContext.SaveChanges();
            // powiazanie zmiany statusu z funkcjonalnoscia
            FeatureStatusChange fsc = new FeatureStatusChange { FeatureId = feature.Id, StatusChangeId = sc.Id };
            _dataContext.FeatureStatusChange.Add(fsc);
            _dataContext.SaveChanges();
            if (feature.IsToTeam)
            {
                FeatureTeam ft = new FeatureTeam();
                ft.FeatureId = feature.Id;
                ft.TeamId = _dataContext.Team.Where(x => x.ProjectId == feature.ProjectId && x.Name == receiver).FirstOrDefault().Id;
                _dataContext.FeatureTeam.Add(ft);
            }
            else
            {
                FeatureUser fu = new FeatureUser();
                fu.FeatureId = feature.Id;
                fu.UserId = _dataContext.Users.Where(x => x.Login == receiver).FirstOrDefault().Id;
                _dataContext.FeatureUser.Add(fu);
            }
            _dataContext.SaveChanges();
        }

        /// <summary>
        /// Metoda pozwalająca pobrać funkcjonalność przy pomocy identyfikatora funkcjonalności.
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <param name="featureId">Identyfikator funkcjonalności.</param>
        /// <returns>Funkcjonalność.</returns>
        public Feature GetFeatureById(int featureId)
        {
            return _dataContext.Feature.Where(x => x.Id == featureId).FirstOrDefault();
        }

        /// <summary>
        /// Metoda pozwalająca edytować funkcjonalność.
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <param name="feature">Nowe dane funkcjonalności.</param>
        /// <param name="featureTeam">Zespół przypisany do funkcjonalności.</param>
        /// <param name="featureUser">Uczestnik przypisany do funkcjonalności.</param>
        public void EditFeature(Feature feature, string featureTeam, string featureUser)
        {
            Feature featureInDatabase = _dataContext.Feature.Where(x => x.Id == feature.Id).FirstOrDefault();
            bool oldRelation = featureInDatabase.IsToTeam;
            featureInDatabase.IsToTeam = feature.IsToTeam;
            featureInDatabase.Name = feature.Name;
            featureInDatabase.PlannedEndDate = feature.PlannedEndDate;
            featureInDatabase.Priority = feature.Priority;
            featureInDatabase.ReleaseId = feature.ReleaseId;
            featureInDatabase.Description = feature.Description;
            DbEntityEntry entry = _dataContext.Entry(featureInDatabase);
            entry.State = EntityState.Modified;
            _dataContext.SaveChanges();
            // teraz pytanie czy zmieniło się powiązanie
            if (featureInDatabase.IsToTeam)
            {
                Team team = _dataContext.Team.Where(x => x.ProjectId == featureInDatabase.ProjectId && x.Name == featureTeam).FirstOrDefault();
                // przypisanie jest do teamu
                if (oldRelation) // bylo juz do teamu
                {
                    FeatureTeam ft = _dataContext.FeatureTeam.Where(x => x.FeatureId == featureInDatabase.Id).FirstOrDefault();
                    if (ft.TeamId != team.Id)
                    {
                        _dataContext.FeatureTeam.Remove(ft);
                        FeatureTeam ftNew = new FeatureTeam { FeatureId = featureInDatabase.Id, TeamId = team.Id };
                        _dataContext.FeatureTeam.Add(ftNew);
                    }
                }
                else
                {
                    // bylo do usera
                    FeatureUser fu = _dataContext.FeatureUser.Where(x => x.FeatureId == featureInDatabase.Id).FirstOrDefault();
                    _dataContext.FeatureUser.Remove(fu);
                    FeatureTeam ftNew = new FeatureTeam { FeatureId = featureInDatabase.Id, TeamId = team.Id };
                    _dataContext.FeatureTeam.Add(ftNew);
                }
            }
            else
            {
                User user = _dataContext.Users.Where(x => x.Login == featureUser).FirstOrDefault();
                // przypisanie jest do usera
                if (!oldRelation)
                {
                    // bylo juz do usera
                    FeatureUser fu = _dataContext.FeatureUser.Where(x => x.FeatureId == featureInDatabase.Id).FirstOrDefault();
                    if (fu.UserId != user.Id)
                    {
                        // zmienil sie uzytkownik
                        _dataContext.FeatureUser.Remove(fu);
                        FeatureUser fuNew = new FeatureUser { FeatureId = featureInDatabase.Id, UserId = user.Id };
                        _dataContext.FeatureUser.Add(fuNew);
                    }
                }
                else
                {
                    // bylo do teamu
                    FeatureTeam ft = _dataContext.FeatureTeam.Where(x => x.FeatureId == featureInDatabase.Id).FirstOrDefault();
                    _dataContext.FeatureTeam.Remove(ft);
                    FeatureUser fuNew = new FeatureUser { FeatureId = featureInDatabase.Id, UserId = user.Id };
                    _dataContext.FeatureUser.Add(fuNew);
                }
            }
            _dataContext.SaveChanges();
        }

        /// <summary>
        /// Metoda zmieniająca status funkcjonalności i zapisująca dokonane zmiany.
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <param name="feature">Obiekt funkcjonalności.</param>
        /// <param name="statusChange">Obiekt zmiany statusu.</param>
        public void ChangeFeatureStatus(Feature feature, StatusChange statusChange)
        {
            feature.Status = statusChange.NewStatus;
            DbEntityEntry entry = _dataContext.Entry(feature);
            entry.State = EntityState.Modified;
            _dataContext.StatusChange.Add(statusChange);
            _dataContext.SaveChanges();
            FeatureStatusChange fsc = new FeatureStatusChange { FeatureId = feature.Id, StatusChangeId = statusChange.Id };
            _dataContext.FeatureStatusChange.Add(fsc);
            _dataContext.SaveChanges();
        }

        /// <summary>
        /// Metoda pozwala pobrać wszystkei zmiany statusu danej funkcjonalności.
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <param name="release">Obiekt funkcjonalności.</param>
        /// <param name="statsusChanges">Tablica zmian statusów funkcjonalności.</param>
        /// <param name="users">Tablica użytkowników zmieniających status.</param>
        public void GetFeatureStatusChanges(Feature feature, out StatusChange[] statusChanges, out string[] users)
        {
            int[] featureStatusChangesId = _dataContext.FeatureStatusChange.Where(x => x.FeatureId == feature.Id)
                .Select(x => x.StatusChangeId).ToArray();
            statusChanges = _dataContext.StatusChange
                .Where(x => featureStatusChangesId.Contains(x.Id)).ToArray();
            users = new string[statusChanges.Length];
            for (int i = 0; i < users.Length; i++)
            {
                StatusChange statusChange = statusChanges[i];
                users[i] = _dataContext.Users.Where(x => x.Id == statusChange.UserId).Select(x => x.Login).FirstOrDefault();
            }
        }

        /// <summary>
        /// Metoda zwracająca wszystkei funkcjonalności przypisane do danego uczestnika z danego projektu.
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <param name="userId">Identyfikator użytkownika.</param>
        /// <param name="projectId">Identyfikator projektu.</param>
        /// <returns>Tablica funkcjonalności przypisanych do użytkownika.</returns>
        public Feature[] GetUserFeatures(int userId, int projectId)
        {
            IEnumerable<int> fuTab = _dataContext.FeatureUser.Where(x => x.UserId == userId).Select(x=>x.FeatureId).Distinct();
            List<Feature> features = new List<Feature>();
            int i = 0;
            foreach (int fu in fuTab)
            {
                Feature tmp = _dataContext.Feature.Where(x => x.Id == fu).FirstOrDefault();
                if (tmp.ProjectId == projectId)
                    features.Add(tmp); 
            }
            return features.ToArray();
        }

        /// <summary>
        /// Metoda zwracająca wszystkei funkcjonalności przypisane do danego zespołu z danego projektu.
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <param name="teamId">Identyfikator zespołu.</param>
        /// <param name="projectId">Identyfikator projektu.</param>
        /// <returns>Tablica funkcjonalności przypisanych do zespołu.</returns>
        public Feature[] GetTeamFeatures(int teamId, int projectId)
        {
            IEnumerable<int> fuTab = _dataContext.FeatureTeam.Where(x => x.TeamId == teamId).Select(x => x.FeatureId).Distinct();
            List<Feature> features = new List<Feature>();
            int i = 0;
            foreach (int fu in fuTab)
            {
                Feature tmp = _dataContext.Feature.Where(x => x.Id == fu).FirstOrDefault();
                if (tmp.ProjectId == projectId)
                    features.Add(tmp);
            }
            return features.ToArray();
        }

        /// <summary>
        /// Metoda pozwala pobrać funkcjonalność na podstawie jej nazwy i projektu do którego należy.
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <param name="featureName">Nazwa funkcjonalności.</param>
        /// <param name="projectId">Identyfikator projektu.</param>
        /// <returns>Funkcjonalność.</returns>
        public Feature GetFeatureByName(string featureName, int projectId)
        {
            return _dataContext.Feature.Where(x => x.ProjectId == projectId && x.Name == featureName).FirstOrDefault();
        }

        #endregion

        #region Taski

        /// <summary>
        /// Metoda do pobrania wszystkich zadań będących w projekcie.
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <param name="projectId">Identyfikator projektu.</param>
        /// <returns>Tablica zadań.</returns>
        public Task[] GetProjectTasks(int projectId)
        {
            return _dataContext.Task.Where(x => x.ProjectId == projectId).ToArray();
        }

        /// <summary>
        /// Metoda pozwalająca dodać do bazy danych nowe zadanie.
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <param name="task">Zadanie.</param>
        /// <param name="creatorId">Identyfikator uczestnika dodającego zadanie.</param>
        public void AddNewTask(Task task, int creatorId)
        {
            _dataContext.Task.Add(task);
            // dodanie zmiany statusu funkcjonalności
            StatusChange sc = new StatusChange
            {
                Comment = "Dodanie nowego zadania",
                DateOfChange = DateTime.Now,
                NewStatus = task.Status,
                OldStatus = null,
                UserId = creatorId
            };
            _dataContext.StatusChange.Add(sc);
            // pierwszy zapis
            _dataContext.SaveChanges();
            // powiazanie zmiany statusu z funkcjonalnoscia
            TaskStatusChange tsc = new TaskStatusChange { TaskId = task.Id, StatusChangeId = sc.Id };
            _dataContext.TaskStatusChange.Add(tsc);
            _dataContext.SaveChanges();
        }

        /// <summary>
        /// Metoda pozwalająca pobrać obiekt zadania na podstawie identyfikatora.
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <param name="taskId">Identyfikator zadania.</param>
        /// <returns>Obiket zadania.</returns>
        public Task GetTaskById(int taskId)
        {
            return _dataContext.Task.Where(x => x.Id == taskId).FirstOrDefault();
        }

        /// <summary>
        /// Metoda do edycji zadania.
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <param name="task">Wydytoane zadanie.</param>
        public void EditTask(Task task)
        {
            Task taskInDatabase = _dataContext.Task.Where(x => x.Id == task.Id).FirstOrDefault();
            if (taskInDatabase == null)
                return;
            taskInDatabase.Name = task.Name;
            taskInDatabase.PlannedStopDate = task.PlannedStopDate;
            taskInDatabase.Priority = task.Priority;
            taskInDatabase.UserId = task.UserId;
            taskInDatabase.FeatureId = task.FeatureId;
            taskInDatabase.Description = task.Description;
            DbEntityEntry entry = _dataContext.Entry(taskInDatabase);
            entry.State = EntityState.Modified;
            _dataContext.SaveChanges();
        }

        /// <summary>
        /// Metoda pozwala pobrać zadania przypisane do użytkownika w ramach konkretnego prpjektu.
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <param name="userId">Identyfikator uczestnika.</param>
        /// <param name="projectId">Identyfikator projektu.</param>
        /// <returns>Tablica zadań do wykonania.</returns>
        public Task[] GetUserTasks(int userId, int projectId)
        {
            return _dataContext.Task.Where(x => x.UserId == userId && x.ProjectId == projectId).ToArray();
        }

        /// <summary>
        /// Metoda pozwala pobrać wszystkie zmiany statusu danego zadania.
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <param name="release">Obiekt zadania.</param>
        /// <param name="statsusChanges">Tablica zmian statusów zadania.</param>
        /// <param name="users">Tablica użytkowników zmieniających status.</param>
        public void GetTaskStatusChanges(Task task, out StatusChange[] statusChanges, out string[] users)
        {
            int[] taskStatusChangesId = _dataContext.TaskStatusChange.Where(x => x.TaskId == task.Id)
                .Select(x => x.StatusChangeId).ToArray();
            statusChanges = _dataContext.StatusChange
                .Where(x => taskStatusChangesId.Contains(x.Id)).ToArray();
            users = new string[statusChanges.Length];
            for (int i = 0; i < users.Length; i++)
            {
                StatusChange statusChange = statusChanges[i];
                users[i] = _dataContext.Users.Where(x => x.Id == statusChange.UserId).Select(x => x.Login).FirstOrDefault();
            }
        }

        /// <summary>
        /// Metoda zmieniająca status zadania i zapisująca dokonane zmiany.
        /// Autor: Jakub Szatkowski
        /// </summary>
        /// <param name="feature">Obiekt zadania.</param>
        /// <param name="statusChange">Obiekt zmiany statusu.</param>
        public void ChangeTaskStatus(Task task, StatusChange statusChange)
        {
            task.Status = statusChange.NewStatus;
            DbEntityEntry entry = _dataContext.Entry(task);
            entry.State = EntityState.Modified;
            _dataContext.StatusChange.Add(statusChange);
            _dataContext.SaveChanges();
            TaskStatusChange tsc = new TaskStatusChange { TaskId = task.Id, StatusChangeId = statusChange.Id };
            _dataContext.TaskStatusChange.Add(tsc);
            _dataContext.SaveChanges();
        }

        public string GetUserbyTaskID(int taskid)
        {

            int userr = _dataContext.Task.Where(a => a.Id == taskid).First().UserId;
            string login = _dataContext.Users.Where(a => a.Id == userr).First().Login;
            return login;
        
        }
        #endregion

        #region komentarze

        public Comment[] GetProjectComment(int id_project)
        {
            return _dataContext.Comments.Where(X=>X.Id_Project==id_project).ToArray();
        }

        public void AddComment(Comment c)
        {
            _dataContext.Comments.Add(c);
            _dataContext.SaveChanges();

        }
        #endregion

        public List<Post> GetTopicPosts(int topicID)
        {
            return _dataContext.Post.Where(x => x.TopicId == topicID).ToList();
        }

        public ForumTopic GetTopicById(int id)
        {
            return _dataContext.ForumTopic.Where(x => x.Id == id).FirstOrDefault();
        }

        /// <summary>
        /// Pobranie zespołów, którymi zarządza dany lider z danego projektu.
        /// </summary>
        /// <param name="projectId"></param>
        /// <param name="userId"></param>
        /// <returns></returns>
        public Team[] GetTeamsManageByUser(int projectId, int userId)
        {
            return _dataContext.Team.Where(x => x.ProjectId == projectId && x.LeaderId == userId).ToArray();
        }

        public int GetProjectIDByTopic(int idtopic)
        {
            return _dataContext.ForumTopic.Where(x => x.Id == idtopic).First().ProjectId;

        }
    }

}
